/*-------------------------------------------------------------------------------------
文件：Bsp_uart.c
功能串口驱动程序
作者：zty
版本: V1.0

-------------------------------------------------------------------------------------*/
/* Includes-----------------------------------------------------------------------------------*/
#include <Bsp_iap.h>
#include <Bsp_uart.h>
#include "usart.h"
#include "tim.h"
#include "user_protocol.h"
#include "modbus_master.h"
#include "protocol_adapter.h"
#include <string.h>
#include <stdio.h>
#if RS485
#include "RS485.h"
#endif /*RS485*/
#if NB_IOT
#include "NB_IOT.h"
#endif /*NB_IOT*/

#include "can.h"

#if LORA
#include "lora.h"
#endif /*LORA*/
/* Private define-----------------------------------------------------------------------------*/

/* Private typedef----------------------------------------------------------------------------*/

/* Private macro------------------------------------------------------------------------------*/

/* Private variables--------------------------------------------------------------------------*/
#if RS485
uint8_t u485_rx_flag = 0;                          //485接收到信息标志
uint8_t u485_rx_buffer[buff_test];
uint32_t u485_rx_len;
#endif /*RS485*/

uint8_t connent_rx_flag = 0;                       //麦尔通接收到信息标志
uint8_t connent_rx_buffer[buff_size];
uint32_t connent_rx_len;
uint8_t QS96_clean_flag = 0;//计数器清零标志位
uint8_t QS96_getdata_flag = 0;//读取计数器数据的标志位
uint8_t QS96_clean_single_flag = 0;//单个计数器清零标志位
uint8_t QS96_getdata_single_flag = 0;//单个计数器读取标志位



#if RS232_1
uint8_t u2321_rx_flag = 0;                         //232 1接收到信息标志
uint8_t u2321_rx_buffer[buff_test];
uint32_t u2321_rx_len;
#endif /*RS232_1*/

#if LORA
uint8_t lora_rx_flag = 0;
uint8_t lora_rx_buffer[buff_test];
uint32_t lora_rx_len;
#endif /*LORA*/

#if NB_IOT
uint8_t nbiot_rx_flag;
uint8_t nbiot_rx_buffer[buff_test];
uint32_t nbiot_rx_len;
#endif /*NB_IOT*/

#if G4_CAT1
uint8_t g4cat1_rx_flag;
uint8_t g4cat1_rx_buffer[buff_test];
uint32_t g4cat1_rx_len;
#endif /*G4_CAT1*/

uint8_t flash_buf[flash_size];
uint32_t flash_len;
uint8_t flash_flag = 0;
uint8_t time_count = 0;                             //响应计数器


uint8_t flag_232 = 1,flag_485 = 0;                  //标记
uint16_t len_num[100] = {0};
uint8_t a = 0;


EDGE_STATUS_T edge_status;                           //边缘网关状态
extern uint8_t QS96_clean_step;
extern uint8_t QS96_collect_step;
extern uint8_t QS96_collect_send_flag;
extern uint8_t light_step;
/* Private function prototypes----------------------------------------------------------------*/

/* Private functions--------------------------------------------------------------------------*/
/***********************************************************************************************
* Description   : 串口接收空闲中断
* Input         :
* Output        :
* Note(s)       :
* Contributor   : 20220225    zhangtingying
***********************************************************************************************/
void usart3_rx_anaylse(void)
{
	if ((connent_rx_len == 6) &&(connent_rx_buffer[0] == 0x68) &&(connent_rx_buffer[5] == 0x16))  //接到灯改变状态指令
	{
		light_step = 3;
		if (connent_rx_buffer[1] == 0xBA)//红
		{
			if (connent_rx_buffer[2] == 0x01)
			{
				mIO_Order |= IO_ORDER_RED;
				mIO_Data = IO_CONTROL_SET;
			}
			else if (connent_rx_buffer[2] == 0x00)
			{
				mIO_Order |= IO_ORDER_RED;
				mIO_Data = IO_CONTROL_RESET;
			}
		}
		else if (connent_rx_buffer[1] == 0xBB)//黄
		{
			if (connent_rx_buffer[2] == 0x01)
			{
				mIO_Order |= IO_ORDER_YELLOW;
				mIO_Data = IO_CONTROL_SET;
			}
			else if (connent_rx_buffer[2] == 0x00)
			{
				mIO_Order |= IO_ORDER_YELLOW;
				mIO_Data = IO_CONTROL_RESET;
			}
		}
		else if (connent_rx_buffer[1] == 0xBC)//绿
		{
			if (connent_rx_buffer[2] == 0x01)
			{
				mIO_Order |= IO_ORDER_GREEN;
				mIO_Data = IO_CONTROL_SET;
			}
			else if (connent_rx_buffer[2] == 0x00)
			{
				mIO_Order |= IO_ORDER_GREEN;
				mIO_Data = IO_CONTROL_RESET;
			}
		}
	}
	if(edge_status == EDGE_PREOPERATE)                                          //启动状态，编译已完成，等待接收并执行bootloader
	{

		if((connent_rx_len == 3)&&(connent_rx_buffer[0]==0xAA)&&(connent_rx_buffer[1]==0xAA)&&(connent_rx_buffer[2]==0xAA))
		{ //收到下发的指令
			flash_flag = 1;
					Send_Data(&huart3,connent_rx_buffer,connent_rx_len);
			flash_len = 0;
//					NVIC_SystemReset(); //软件重启
		}

		else if((connent_rx_len == 3) &&
				(connent_rx_buffer[0]==0xBB)&&
				(connent_rx_buffer[1]==0xBB) &&
				(connent_rx_buffer[2]==0xBB))
		{
//					Send_Data(&huart3,connent_rx_buffer,connent_rx_len);
//					iap_write_appbin(FLASH_APP1_ADDR,flash_buf,flash_len);     //更新flash代码
			finish_flag = 1;
		}

		if (flash_flag)
		{

			if (flash_flag > 1) {
				memcpy(&flash_buf[flash_len],connent_rx_buffer,connent_rx_len);
				len_num[flash_flag] = connent_rx_len;
				flash_len += connent_rx_len;
			}
			flash_flag ++;
		}
	}
	else if(edge_status == EDGE_OPERATE)
	{
		if (connent_rx_buffer[0] == 0x68)
		{	//接到采集指令
			if((connent_rx_buffer[1] == 0xC0) &&(connent_rx_buffer[2] == 0x16))
			{
//					finish_flag = 1;
				#if MODBUS_232_1
				//	read_finish = 0;
				#endif /*MODBUS_232_1*/

				#if MODBUS_485
					m485_sum_info.read_finish = 0;
				#endif /*MODBUS_485*/
			}
			if(connent_rx_buffer[1] == 0xAB)//接到配置指令
			{
				uint8_t data_cmd[]={0xAB,0xAB,0xAB};//给网关
				Send_Data(&huart3, (uint8_t*)data_cmd, strlen(data_cmd));//告诉网关接到状态切换指令
			}
		}
	}
	//计数器
	if((connent_rx_buffer[0]==0xB1)&&(connent_rx_buffer[1]==0xB1) && (QS96_clean_flag == 0))
	{
		QS96_clean_flag = 1;
		QS96_clean_step = 7;
	}
	if((connent_rx_buffer[0]==0xB2)&&(connent_rx_buffer[1]==0xB2) && (QS96_getdata_flag == 0))
//	if((connent_rx_buffer[0]==0xB2)&&(connent_rx_buffer[1]==0xB2))
	{
		QS96_getdata_flag = 1;
		QS96_collect_step = 8;
		QS96_collect_send_flag = 1;
	}
	if((connent_rx_buffer[0]==0xB3)&&(connent_rx_buffer[1]==0xB3))
	{
		QS96_clean_single_flag = 1;
	}
	if((connent_rx_buffer[0]==0xB4)&&(connent_rx_buffer[1]==0xB4))
	{
		QS96_getdata_single_flag = 1;
	}
}









void UsartReceive_IDLE(UART_HandleTypeDef *huart)
{
    uint16_t i = 0;
    if((__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET))
    {
		#if NB_IOT
			if(huart->Instance == UART4)                                            //232
			  {
				__HAL_UART_CLEAR_IDLEFLAG(huart);                                      //清除空闲中断标志位
				i = huart->Instance->SR;                                               //清除SR状态寄存器
				i = huart->Instance->DR;                                               //读取DR数据寄存器
				i  = __HAL_DMA_GET_COUNTER(&hdma_uart4_rx);						       //获取DMA中未传输的数据个数
				HAL_UART_DMAStop(huart);

				/* 此处处理数据，主要是拷贝和置位标志位 */
				nbiot_rx_len = flash_rx - i;
				nbiot_rx_flag = 1;
				//打印一下收到的数据
				HAL_UART_Receive_DMA(huart,(uint8_t *)&nbiot_rx_buffer[0],flash_rx);
			   }
		#endif /*NB_IOT*/

		#if LORA
		if(huart->Instance == UART5)                                            //232
		{
			__HAL_UART_CLEAR_IDLEFLAG(huart);                                      //清除空闲中断标志位
			i = huart->Instance->SR;                                               //清除SR状态寄存器
			i = huart->Instance->DR;                                               //读取DR数据寄存器
			i  = __HAL_DMA_GET_COUNTER(&hdma_uart5_rx);						       //获取DMA中未传输的数据个数
			HAL_UART_DMAStop(huart);

			/* 此处处理数据，主要是拷贝和置位标志位 */
			lora_rx_len = flash_rx - i;
			lora_rx_flag = 1;
			//收到的信息打印一下

			HAL_UART_Receive_DMA(huart,(uint8_t *)&lora_rx_buffer[0],flash_rx);
		}
		#endif /*LORA*/

		#if RS232_1
				if(huart->Instance == USART1)                                      //232 1
			   {
					__HAL_UART_CLEAR_IDLEFLAG(huart);                                      //清除空闲中断标志位
					i = huart->Instance->SR;                                               //清除SR状态寄存器
					i = huart->Instance->DR;                                               //读取DR数据寄存器
					i  = __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);						       //获取DMA中未传输的数据个数
					HAL_UART_DMAStop(huart);

					/* 此处处理数据，主要是拷贝和置位标志位 */
					u2321_rx_len = buff_size - i;
					u2321_rx_flag = 1;
		#if RS232_232_1
		//			Analyse_info(u2321_rx_buffer,u2321_rx_len,1);
		#endif /*RS232_232_1*/

		#if MODBUS_232_1
		//			M_Analyse_info(u2321_rx_buffer,u2321_rx_len);
		#endif /*MODBUS_232_1*/

					HAL_UART_Receive_DMA(huart,(uint8_t *)&u2321_rx_buffer[0],buff_size);

			   }
		#endif /*RS232_1*/

		#if G4_CAT1
				if(huart->Instance == USART2)
				{
					__HAL_UART_CLEAR_IDLEFLAG(huart);                                   //清除空闲中断标志位
					i = huart->Instance->SR;                                            //清除SR状态寄存器
					i = huart->Instance->DR;                                            //读取DR数据寄存器
					i  = __HAL_DMA_GET_COUNTER(&hdma_usart2_rx);						//获取DMA中未传输的数据个数
					HAL_UART_DMAStop(huart);

					/* 此处处理数据，主要是拷贝和置位标志位 */
					g4cat1_rx_len = buff_size - i;
					g4cat1_rx_flag = 1;                                                   //接收标志位置1
//					#if MQTT_4G_CAT1
//						tran_mqtt(g4cat1_rx_buffer,g4cat1_rx_len);
//					#endif /*MQTT_4G_CAT1*/
					HAL_UART_Receive_DMA(huart,(uint8_t *)&g4cat1_rx_buffer[0],buff_size);
				}

		#endif /*4G_CAT1*/

        if(huart->Instance == USART3)                                              //麦尔通   等待更新成新逻辑
	   {
			__HAL_UART_CLEAR_IDLEFLAG(huart);                                      //清除空闲中断标志位
			i = huart->Instance->SR;                                               //清除SR状态寄存器
			i = huart->Instance->DR;                                               //读取DR数据寄存器
			i  = __HAL_DMA_GET_COUNTER(&hdma_usart3_rx);						       //获取DMA中未传输的数据个数
			HAL_UART_DMAStop(huart);

			/* 此处处理数据，主要是拷贝和置位标志位 */
			connent_rx_len = buff_size - i;
			connent_rx_flag =1;
			if(connent_rx_len > 1)
			{
				usart3_rx_anaylse();
			}


//			if ((connent_rx_len == 6) &&(connent_rx_buffer[0] == 0x68) &&(connent_rx_buffer[5] == 0x16))  //接到灯改变状态指令
//			{
//				if (connent_rx_buffer[1] == 0xBA)//红
//				{
//					if (connent_rx_buffer[2] == 0x01)
//					{
//						mIO_Order |= IO_ORDER_RED;
//						mIO_Data = IO_CONTROL_SET;
//					}
//					else if (connent_rx_buffer[2] == 0x00)
//					{
//						mIO_Order |= IO_ORDER_RED;
//						mIO_Data = IO_CONTROL_RESET;
//					}
//				}
//				else if (connent_rx_buffer[1] == 0xBB)//黄
//				{
//					if (connent_rx_buffer[2] == 0x01)
//					{
//						mIO_Order |= IO_ORDER_YELLOW;
//						mIO_Data = IO_CONTROL_SET;
//					}
//					else if (connent_rx_buffer[2] == 0x00)
//					{
//						mIO_Order |= IO_ORDER_YELLOW;
//						mIO_Data = IO_CONTROL_RESET;
//					}
//				}
//				else if (connent_rx_buffer[1] == 0xBC)//绿
//				{
//					if (connent_rx_buffer[2] == 0x01)
//					{
//						mIO_Order |= IO_ORDER_GREEN;
//						mIO_Data = IO_CONTROL_SET;
//					}
//					else if (connent_rx_buffer[2] == 0x00)
//					{
//						mIO_Order |= IO_ORDER_GREEN;
//						mIO_Data = IO_CONTROL_RESET;
//					}
//				}
//			}
//			if(edge_status == EDGE_PREOPERATE)                                          //启动状态，编译已完成，等待接收并执行bootloader
//			{
//
//				if((connent_rx_len == 3)&&(connent_rx_buffer[0]==0xAA)&&(connent_rx_buffer[1]==0xAA)&&(connent_rx_buffer[2]==0xAA))
//				{ //收到下发的指令
//					flash_flag = 1;
////					Send_Data(&huart3,connent_rx_buffer,connent_rx_len);
//					flash_len = 0;
////					NVIC_SystemReset(); //软件重启
//				}
//
//				else if((connent_rx_len == 3) &&
//						(connent_rx_buffer[0]==0xBB)&&
//						(connent_rx_buffer[1]==0xBB) &&
//						(connent_rx_buffer[2]==0xBB))
//				{
////					Send_Data(&huart3,connent_rx_buffer,connent_rx_len);
////					iap_write_appbin(FLASH_APP1_ADDR,flash_buf,flash_len);     //更新flash代码
//					finish_flag = 1;
//				}
//
//				if (flash_flag)
//				{
//
//					if (flash_flag > 1) {
//						memcpy(&flash_buf[flash_len],connent_rx_buffer,connent_rx_len);
//						len_num[flash_flag] = connent_rx_len;
//						flash_len += connent_rx_len;
//					}
//					flash_flag ++;
//				}
//			}
//			else if(edge_status == EDGE_OPERATE)
//			{
//				if (connent_rx_buffer[0] == 0x68)
//				{	//接到采集指令
//					if((connent_rx_buffer[1] == 0xC0) &&(connent_rx_buffer[2] == 0x16))
//					{
//	//					finish_flag = 1;
//						#if MODBUS_232_1
//						//	read_finish = 0;
//						#endif /*MODBUS_232_1*/
//
//						#if MODBUS_485
//							m485_sum_info.read_finish = 0;
//						#endif /*MODBUS_485*/
//					}
//					if(connent_rx_buffer[1] == 0xAB)//接到配置指令
//					{
//						uint8_t data_cmd[]={0xAB,0xAB,0xAB};//给网关
//						Send_Data(&huart3, (uint8_t*)data_cmd, strlen(data_cmd));//告诉网关接到状态切换指令
//					}
//				}
//			}
//			//计数器
//			if((connent_rx_buffer[0]==0xB1)&&(connent_rx_buffer[1]==0xB1) && (QS96_clean_flag == 0))
//			{
//				QS96_clean_flag = 1;
//				QS96_clean_step = 4;
//			}
//			if((connent_rx_buffer[0]==0xB2)&&(connent_rx_buffer[1]==0xB2))
//			{
//				QS96_getdata_flag = 1;
//			}
//			if((connent_rx_buffer[0]==0xB3)&&(connent_rx_buffer[1]==0xB3))
//			{
//				QS96_clean_single_flag = 1;
//			}
//			if((connent_rx_buffer[0]==0xB4)&&(connent_rx_buffer[1]==0xB4))
//			{
//				QS96_getdata_single_flag = 1;
//			}
			HAL_UART_Receive_DMA(huart,(uint8_t *)&connent_rx_buffer[0],buff_size);
	   }
/*
 * 串口6
 */
		#if RS485
        if(huart->Instance == USART6)
		{
			__HAL_UART_CLEAR_IDLEFLAG(huart);                                   //清除空闲中断标志位
			i = huart->Instance->SR;                                            //清除SR状态寄存器
			i = huart->Instance->DR;                                            //读取DR数据寄存器
			i  = __HAL_DMA_GET_COUNTER(&hdma_usart6_rx);						//获取DMA中未传输的数据个数
			HAL_UART_DMAStop(huart);

			/* 此处处理数据，主要是拷贝和置位标志位 */
			u485_rx_len = buff_size - i;
			u485_rx_flag = 1;                                                   //接收标志位置1
			#if RS485_DB9
						Analyse_info(u485_rx_buffer,u485_rx_len,2);
			#endif /*RS485_DB9*/

			#if MODBUS_485
						RX_Analyse_info(u485_rx_buffer,u485_rx_len);
			//			Send_Data(&huart1,u485_rx_buffer,u485_rx_len);
			#endif /*MODBUS_485*/
			HAL_UART_Receive_DMA(huart,(uint8_t *)&u485_rx_buffer[0],buff_size);
		}
		#endif /*RS485*/

//       if(huart->Instance == UART5)                                       //232 2
//	   {
//			__HAL_UART_CLEAR_IDLEFLAG(huart);                                      //清除空闲中断标志位
//			i = huart->Instance->SR;                                               //清除SR状态寄存器
//			i = huart->Instance->DR;                                               //读取DR数据寄存器
//			i  = __HAL_DMA_GET_COUNTER(&hdma_uart5_rx);						       //获取DMA中未传输的数据个数
//			HAL_UART_DMAStop(huart);
//
//			/* 此处处理数据，主要是拷贝和置位标志位 */
//			u2322_rx_len = flash_rx - i;
//			u2322_rx_flag = 1;
//
//
//			if(edge_status == EDGE_PREOPERATE)                           //发送指令、需求
//			{
//				analysis_pct_adapter(u2322_rx_buffer,u2322_rx_len);
//			}
//			else if(edge_status == EDGE_START)                           //判断是否是下发指令，发送给CP，其他不用管
//			{
//				whether_send_order(u2322_rx_buffer,u2322_rx_len);
//			}
//			else if(edge_status == EDGE_OPERATE)
//			{
//				whether_set_peroperate(u2322_rx_buffer,u2322_rx_len);
//			}
//			HAL_UART_Receive_DMA(huart,(uint8_t *)&u2322_rx_buffer[0],flash_rx);
//	   }

    }
}
/************************************************
函数名称 ： Bsp_usart_enable
功    能 ：串口开启使能
参    数 ： 无
返 回 值 ： 无
*************************************************/
void Bsp_usart_enable()
{

#if NB_IOT
	  __HAL_UART_CLEAR_IDLEFLAG(&huart4);                                             //清除空闲中断标志   NB_IOT
	  __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);                                    //空闲接收中断
	  HAL_UART_Receive_DMA(&huart4,(uint8_t *)&nbiot_rx_buffer[0],flash_rx);           //DMA
#endif /*NB_IOT*/


#if LORA
	  __HAL_UART_CLEAR_IDLEFLAG(&huart5);                                             //清除空闲中断标志   lora
	  __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE);                                    //空闲接收中断
	  HAL_UART_Receive_DMA(&huart5,(uint8_t *)&lora_rx_buffer[0],flash_rx);           //DMA
#endif /*LORA*/

#if RS232_1
	  __HAL_UART_CLEAR_IDLEFLAG(&huart1);                                             //清除空闲中断标志   232 1
	  __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);                                    //空闲接收中断
	  HAL_UART_Receive_DMA(&huart1,(uint8_t *)&u2321_rx_buffer[0],buff_size);         //DMA
#endif /*RS232_1*/

#if G4_CAT1
	  __HAL_UART_CLEAR_IDLEFLAG(&huart2);                                             //清除空闲中断标志   4G_CAT1
	  __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);                                    //空闲接收中断
	  HAL_UART_Receive_DMA(&huart2,(uint8_t *)&g4cat1_rx_buffer[0],buff_size);        //DMA
#endif /*4G_CAT1*/

	  __HAL_UART_CLEAR_IDLEFLAG(&huart3);                                             //清除空闲中断标志    麦尔通
	  __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);                                    //空闲接收中断
	  HAL_UART_Receive_DMA(&huart3,(uint8_t *)&connent_rx_buffer[0],buff_size);       //DMA

#if RS485
	  EN485_L;                                                                        //使能485
	  __HAL_UART_CLEAR_IDLEFLAG(&huart6);                                             //清除空闲中断标志   485
	  __HAL_UART_ENABLE_IT(&huart6, UART_IT_IDLE);                                    //空闲接收中断
	   HAL_UART_Receive_DMA(&huart6,(uint8_t *)&u485_rx_buffer[0],buff_size);         //DMA
#endif /*RS485*/

}
/************************************************
函数名称 ： Send_Data_485
功    能 ： 发送size个字节
参    数 ： buf 发送首地址   size发送字节数（小于128）
返 回 值 ： 无
*************************************************/
void Send_Data(UART_HandleTypeDef *huart,uint8_t *buf,uint8_t size)
{
	size=size>buff_size ? buff_size:size;

	#if NB_IOT
		if(huart->Instance == UART4)
			HAL_UART_Transmit(&huart4,buf,size,0xffff);
	#endif /*NB_IOT*/

	#if LORA
		if(huart->Instance == UART5)
			HAL_UART_Transmit(&huart5,buf,size,0xffff);
	#endif /*LORA*/

	#if RS232_1
		if(huart->Instance == USART1)
			HAL_UART_Transmit(&huart1,buf,size,0xffff);
	#endif /*RS232_1*/

	#if G4_CAT1
		if(huart->Instance == USART2)
			HAL_UART_Transmit(&huart2,buf,size,0xffff);
	#endif /*4G_CAT1*/

		if(huart->Instance == USART3)
			HAL_UART_Transmit(&huart3,buf,size,0xffff);

	#if RS485
		if(huart->Instance == USART6)
		{
			EN485_H;
			HAL_UART_Transmit(&huart6,buf,size,0xffff);
			EN485_L;
		}
	#endif /*RS485*/

}
/************************************************
函数名称 ： Send_answer
功    能 ： 处理收到数据并应答一次
参    数 ： 无
返 回 值 ： 无
*************************************************/
void Send_answer(void)
{
	#if NB_IOT
		if(nbiot_rx_flag)
		{
			nbiot_rx_flag = 0;
			Send_Data(&huart4,nbiot_rx_buffer,nbiot_rx_len);
		}
	#endif /*NB_IOT*/

	#if LORA
		if(lora_rx_flag)
		{
			lora_rx_flag = 0;
			Send_Data(&huart3,(uint8_t*)lora_rx_buffer,lora_rx_len);

		}
	#endif /*LORA*/

	#if RS232_1
		if(u2321_rx_flag)
		{
			Send_Data(&huart1,u2321_rx_buffer,u2321_rx_len);
			u2321_rx_flag = 0;
		}
	#endif /*RS232_1*/

	#if G4_CAT1
		if(g4cat1_rx_flag)
		{
			Send_Data(&huart2,g4cat1_rx_buffer,g4cat1_rx_len);
			g4cat1_rx_flag = 0;
		}
	#endif /*4G_CAT1*/

		if(connent_rx_flag)
		{
			Send_Data(&huart3, connent_rx_buffer, connent_rx_len);
			connent_rx_flag = 0;
		}

	#if RS485
		if(u485_rx_flag)
		{
			Send_Data(&huart6,u485_rx_buffer,u485_rx_len);
			u485_rx_flag = 0;
		}
	#endif  /*RS485*/





}

/************************************************
函数名称 ： HAL_TIM_PeriodElapsedCallback
功    能 ： 定时器回调函数              50ms
参    数 ： 无
返 回 值 ： 无
*************************************************/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim == (&htim3))
	{
		time_count++;
	}
}

